/**
 * String관련 공통모듈
 * 
 * @author KJH
 * @version 1.0, 2012-02-28 
 * @fix([수정자]) [yyyy-mm-dd]: [수정 내용]
 *
 */

/**
 * 함수 리스트
 * 
 * getShortString : String을 byte수만큼 자른 후 출력
 * toEUC_KR : 글자를 한글로 변환하는 함수
 * isCheckHan : 한글인지 아닌지 판단
 * checkPattern	: 형식에 맞는지 판단
 * isEmail : 정상적인 메일 주소인지 판단
 * isSpecialChar : 특수문자가 포함되었는지 판단
 * unicodeTokor : 유니코드를 한글로 변경
 * unicode16Tokor : 16진수 유니코드를 문자열로 변환
 * getUCS2Encode : 문자를 ucs2형식으로 변환
 * getStrArray : String을 구분자로 분리
 * getEmail : Email주소 출력
 * getName	: Email의 이름출력
 * isInclude : 배열에 정보가 포함되어 있는지 검색
 * getMD5 : 데이타를 MD5형식으로 변경
 * getDelTag : 입력받은 데이타의 html태그를 제거
 * getIntegerByString	: String을 Integer형으로 변경
 * getLongByString	: String을 Long형으로 변경
 * getSizeReturn : M,G단위의 숫자로 변경
 *
 */

package com.ubst.smartad.common;

import java.io.ByteArrayOutputStream;
import java.security.MessageDigest;
import java.util.regex.Pattern;
import java.util.Vector;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.text.NumberFormat;

public class StringUtil {

	/**
	 * String을 byte수만큼 자른 후 출력
	 * 
	 * @param str : 원문 String
	 * @param byteSize : 자를 byte수
	 * @param end_str : 원문을 자르고 마지막에 추가할 글자(ex: "..."등)
	 * @return String : 변경된 String
	 *
	*/

	// 한글이나 영문 숫자일 경우를 체크하여 byte수만큼 짜르기
	// substring은 byte단위가 아니라 한글이든 영문이든 string 길이 단위로 짜르는 단점이 있다.
	public  static String getShortString( String str, int byteSize )
	{
			return getShortString(str, byteSize, "...");
	}

	public  static String getShortString( String str, int byteSize, String end_str ){
		int rSize = 0;
		int len = 0;

		if ( str.getBytes().length > byteSize ) {
			for ( ; rSize < str.length(); rSize++ ) {
				if ( str.charAt( rSize ) > 0x007F ){
					len += 2;
				}else {
					len++;
				}

				if ( len > byteSize ){
					break;
				}
			} // end for
			str = str.substring( 0, rSize ) + end_str;
		}

		return str;
	}

	/**
	 * 한글 변환 함수
	 * 
	 * @param str : 원문 String
	 * @return String : 변환된 String
	 *  
	*/
	public static String toEUC_KR(String src, String srcCharset) throws Exception{
		String temp ="";
		try{
			if(srcCharset==null || srcCharset.equals("")){
				srcCharset = "8859_1";
			}
			temp = new String(src.getBytes(srcCharset), "euc-kr");
		}catch (Exception e){
			throw e;
		}
		return temp;
	}

	/**
	 * 한글이 포함되었는지 판단하는 함수
	 * 
	 * @param str : 원문 String
	 * @return boolean : 한글이면 true, 한글이 아니면 false
	 *  
	*/
	public static boolean isCheckHan( String str ){
		boolean check_flag = false;
		if(str==null || str.trim().equals("")){
			return false;
		}else{
			for (int i=0; i<str.length(); i++){
				if ( str.charAt( i ) > 0x007F ) {
					check_flag = true;
					break;
				}
			}
			return check_flag;
		}
	}

	/**
	 * @author KJH
	 * 형식에 맞는지 판단
	 * 
	 * @param str : 원문 String
	 * @param pattern : 판단형식
	 *
	 * @return 판단유무
	 *  
	*/
	public static boolean checkPattern( String str , String pattern){
		boolean b = Pattern.matches(pattern, str);
		return b;
	}

	/**
	 * 메일주소가 정상적인지 판단하는 함수
	 * 
	 * @param email : email주소
	 * @return boolean : 정상이면 true, 정상이 아니면 false
	 *  
	*/
	public static boolean isEmail(String email) {
		if (email==null){
			return false;
		}
		if(email.indexOf("<") > -1 && email.indexOf(">") > -1 ){
			email = email.substring(email.indexOf("<")+1,email.indexOf(">"));
		}

		boolean b = Pattern.matches("[\\w\\~\\-\\.]+@[\\w\\~\\-]+(\\.[\\w\\~\\-]+)+", email.trim());
		return b;
	}

	/**
	 * 특수문자가 포함되었는지 판단
	 * 
	 * @param str : 비교할 원문 데이타
	 * @param exceptChar : 예외특수문자리스트
	 *
	 * @return boolean : 포함이면 true, 포함하지않으면 false
	 *  
	*/
	public static boolean isSpecialChar(String str, String exceptChar) {
		if (str==null){
			return true;
		}

		boolean check_val = false;
		String[] specialchar = {"~","!","@","#","$","%","^","&","*","(",")","_","+","|","`","-","=","\\","{","}","[","]",":",";","\"","'","<",">","?",",",".","/"};
		int special_len = specialchar.length;
		for(int i=0; i<special_len; i++){
			if(exceptChar.indexOf(specialchar[i])!=-1){
				continue;
			}
			if(str.indexOf(specialchar[i])!=-1){
				check_val = true;
				break;
			}
		}
		return check_val;
	}

	/**
	 * String에 포함된 unicode를 한글로 변환하는 함수
	 * 
	 * @param uni_code : 유니코드
	 * @return String : 변경된 String
	 *  
	*/
	public static String unicodeTokor(String uni_code) {
		String kor_value = uni_code;
		java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("&#([0-9]+);"); //검색할 문자열
		java.util.regex.Matcher matcher = pattern.matcher(uni_code);

		String tmp_uni = "";
		String tmp_int = "";
		String tmp_kor = "";
		while (matcher.find()) {
			tmp_uni = matcher.group();
			tmp_int = tmp_uni.substring(2,tmp_uni.length()-1);
			tmp_kor = ""+(char)Integer.parseInt(tmp_int);
			kor_value = kor_value.replace(tmp_uni,tmp_kor);
		}
		return kor_value;
	}

    /** 
	 * @author KJH
     * 16진수 유니코드를 문자열로 변환하는 함수
     *   
     * @param uni_code : 16진수 유니코드
	 *
     * @return String : 변경된 String
     *   
    */  
    public static String unicode16Tokor(String uni_code) {
		StringBuffer kor_value = new StringBuffer();
		StringTokenizer str = new StringTokenizer(uni_code,"\\u");
		String tmp = "";
        while (str.hasMoreTokens()) {
			tmp = str.nextToken();
			int i = Integer.parseInt(tmp, 16);
			kor_value.append((char)i);
        }       
        return kor_value.toString();
    }   

	/**
	 * @author KJH
	 * 문자를 ucs2형식으로 변경한다.
	 * 
	 * @param str : 변환할 글자
	 *
	 * @return ucs2형식의 String
	 *  
	*/
	public static String getUCS2Encode(String str){
		String ucs2encode_str = "";
		ByteArrayOutputStream baos = new ByteArrayOutputStream();

		try {
			byte[] unicode_bytes = null;
			char[] unicode = str.toCharArray();

			for( int i=0; i<unicode.length; i++ ) {
				if( unicode[i] > '\u007F' ) {
					baos.write('&');
					baos.write('#');
					baos.write(Integer.toString((int)(unicode[i]&0xFFFF)).getBytes());
					baos.write(';');
				}
				else {
					baos.write((int)(unicode[i]&0xFFFF));
				}
			}
			unicode_bytes = baos.toByteArray();
			ucs2encode_str = new String(unicode_bytes);	
			baos.close();
		}catch( Exception e ) {
			e.printStackTrace();
		}finally{
			if(baos!=null){
				try{baos.close();}catch(Exception ee){}
			}
		}

		return ucs2encode_str;
    }

	/**
	 * @author KJH
	 * String을 구분자로 분리한다.
	 * 
	 * @param str : 원문 String
	 * @param token : 구분자
	 * @return 구분된 데이타
	 *  
	*/
    public static String[] getStrArray(String str, String token){

		if(str==null || str.trim().equals("")){
			return null;
		}

        StringBuffer sbf = new StringBuffer(str);
        String[] result = null;
        ArrayList v = new ArrayList();
        Object[] obj = null;

        try{
            int tokenLen = token.length();
            int idx=0;

            while(true){
                    if((idx=sbf.indexOf(token)) == -1){
                            v.add(sbf.toString());
                            break;
                    }
                    else{
                            String addStr = sbf.substring(0,idx);
                            v.add(addStr);

                            sbf.delete(0, idx+tokenLen);
                    }
            }

            if(v.size() == 0) return null;

            obj = v.toArray();
            result = new String[obj.length];

            for(int i=0; i<obj.length; i++){
                    //result[i] = (String)obj[i];
                result[i] = obj[i].toString();
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }

        return result;
    }

	/**
	 * @author KJH
	 * email에서 mail주소만 가져온다.
	 * 
	 * @param mail_address : 이름을 포함한 메일주소
	 * @return  메일주소
	 *  
	*/
    public static String getEmail(String str){
        String result = null;
        
        if(str==null || str.equals("") || str.indexOf("@") == -1){
            return null;
        }
        
        int sIdx = str.indexOf("<") ;
        int eIdx = str.indexOf(">") ;
        if(sIdx!=-1 && eIdx!=-1 && sIdx < eIdx ){
            result = str.substring(sIdx+1, eIdx);
        }else{
            result = str;
        }
        
        return result;
	}

	/**
	 * @author KJH
	 * email에서 이름만 가져온다.
	 *
	 * @param str : 이름을 포함한 메일주소
	 * @param flag : Y(이름이 없을겨우 아이디를 리턴), N(이름이 없을 경우 null을 리텅)
	 *
	 * @return 이름 
	 *
	*/
	public static String getName(String str, String flag) {
        String result = null;
        
        if(str==null || str.equals("") || str.indexOf("@") == -1){
            return null;
        }

		int sIdx = str.indexOf("<") ;
        int eIdx = str.indexOf(">") ;
        if(sIdx!=-1 && eIdx!=-1 && sIdx < eIdx ){
            result = str.substring(0,sIdx);
			if(result==null || result.trim().equals("")){
				if(flag!=null && flag.equals("N")){
					result = null;
				}else{
		            result = str.substring(sIdx+1, str.indexOf("@"));
				}
			}
        }else{
			if(flag!=null && flag.equals("N")){
				result = null;
			}else{
	            result = str.substring(0, str.indexOf("@"));
			}
        }
        
        return result;
	}

	/**
	 * @author KJH
	 * 배열에 정보가 포함되어 있는지 검색
	 *
	 * @param array_str : 배열값
	 * @param str : 비교값
     * @return 포함상태값
	 */
	public static boolean isInclude(String[] array_str, String str){
		boolean ret_val = false;
		if(array_str!=null){
			int array_cnt = array_str.length;
			for(int i=0; i<array_cnt; i++){
				if(array_str[i]==null){
					continue;
				}
				if(array_str[i].equals(str)){
					ret_val = true;
					break;
				}
			}
		}
		return ret_val;
	}

	/**
	 * @author KJH (복사)
	 * 입력받은 데이타를 MD5형식으로 변경한다.
	 * 
	 * @param str : 변경할 데이타
	 * @return  MD5데이타
	 *  
	*/
    public static byte[] getMD5(String str){
        MessageDigest md5 = null;
        StringBuffer sb = null; 
		byte[] eee = null;
        
        try{
            md5= MessageDigest.getInstance("MD5");
            md5.update(str.getBytes());
            eee = md5.digest();
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return eee;
    }

	/**
	 * @author KJH
	 * 입력받은 데이타의 html태그를 제거한다.
	 * 
	 * @param str : 변경할 데이타
	 * @return  테그가 제거된 데이타
	 *  
	*/
    public static String getDelTag(String str){
		String _text = str;
       
        try{
			_text = _text.replaceAll("<(/)?([a-zA-Z]*)(\\s[a-zA-Z]*=[^>]*)?(\\s)*(/)?>", "");
        }catch(Exception e){
            e.printStackTrace();
        }
        
        return _text;
    }

	/**
	 * @author KJH
	 * 입력받은 스트링값을 Integer값으로 변환
	 * 
	 * @param str : 변경할 데이타
	 * @param defaultVal : Exception발생시 default값
	 *
	 * @return  Integer값
	 *  
	*/
    public static int getIntegerByString(String str, int defaultVal){
		int ret_val = defaultVal;
        try{
			ret_val = Integer.parseInt(str);
        }catch(NumberFormatException nue){
			ret_val = defaultVal;
        }
        
        return ret_val;
    }

	/**
	 * @author KJH
	 * 입력받은 스트링값을 Long값으로 변환
	 * 
	 * @param str : 변경할 데이타
	 * @param defaultVal : Exception발생시 default값
	 *
	 * @return  Long값
	 *  
	*/
    public static long getLongByString(String str, long defaultVal){
		long ret_val = defaultVal;
        try{
			ret_val = Long.parseLong(str);
        }catch(NumberFormatException nue){
			ret_val = defaultVal;
        }
        
        return ret_val;
    }

	/**
	 * @author KJH
	 * 입력받은 스트링값을 Long값으로 변환
	 * 
	 * @param str : 변경할 데이타
	 * @param defaultVal : Exception발생시 default값
	 *
	 * @return  double값
	 *  
	*/
    public static double getDoubleByString(String str, double defaultVal){
    	double ret_val = defaultVal;
        try{
			ret_val = Double.parseDouble(str);
        }catch(NumberFormatException nue){
			ret_val = defaultVal;
        }
        
        return ret_val;
    }

	/**
	 * @author KJH
	 * 입력받은 값을 Size별로 변환
	 * 
	 *  
	*/
	public static String getSizeReturn(double doublesize, String digit, String type)
	{
		String _digit = "%."+digit+"f";
		String sReturn = "";
		if ( doublesize < 1024.0D ) {
			sReturn = doublesize + " "+type;
		}
		else if ( doublesize >= 1024*1024*1024*1024.0D ) {
			double rdsize = doublesize/(1024*1024*1024*1024.0D);
			rdsize = Double.parseDouble(String.format(_digit,rdsize));
			sReturn = String.valueOf(rdsize)+" T"+type;
		}
		else if ( doublesize >= 1024*1024*1024.0D ) {
			double rdsize = doublesize/(1024*1024*1024.0D);
			rdsize = Double.parseDouble(String.format(_digit,rdsize));
			sReturn = String.valueOf(rdsize)+" G"+type;
		}
		else if ( doublesize >= 1024*1024.0D ) {
			double rdsize = doublesize/(1024*1024.0D);
			rdsize = Double.parseDouble(String.format(_digit,rdsize));
			sReturn = String.valueOf(rdsize)+" M"+type;
		}
		else {
			double rdsize = doublesize/(1024.0D);
			rdsize = Double.parseDouble(String.format(_digit,rdsize));
			sReturn = String.valueOf(rdsize)+" K"+type;
		}
		return new String( sReturn );
	}

	/**
	 * @author KJH
	 * double을 String으로 변환시 E값으로 나오는 부분을 정상적인 숫자로 나오도록 처리
	 * 
	 *  
	*/
	public static String formatDouble(double doublesize)
	{
		String sReturn = "";

		NumberFormat f = NumberFormat.getInstance();
		f.setGroupingUsed(false);
		sReturn = f.format(doublesize);

		return sReturn;
	}

}
